{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "2eae1417",
   "metadata": {},
   "source": [
    "# Variational Quantum Deflation for excited states of molecules"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5b5683a",
   "metadata": {},
   "source": [
    "## Introduction"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7d8bd52",
   "metadata": {},
   "source": [
    "The simulation of excited states of molecular systems is an important task in quantum chemistry with relevance to technologies such as solar energy harvesting, catalysis, optoelectronics, and many others. Quantum computing protocols for accessing molecular excited state properties are therefore currently under active investigation [1–11]. In the NISQ era, approaches based on the Variational Quantum Eigensolver (VQE)[12] algorithm are of particular interest for their ability to represent useful quantum states on near term quantum devices using parameterized quantum circuits while offloading the optimization of the parameters specifying the quantum circuit to classical hardware. The hybrid quantum-classical paradigm implied by VQE and generalizations thereof has therefore undergone rapid development since 2014 [13]. Today most quantum computing platform APIs provide VQE solvers which can be deployed for computing ground state total energies of molecular systems using only a few lines of python code. Excited state solvers such as qEOM [6] are also available as user-friendly implementations [14] and certainly more will be implemented by platform providers in the near future. \n",
    "\n",
    "In this notebook, we will look at a simple extension of VQE to excited states known as Variational Quantum Deflation (VQD)  [11] which allows for the sequential computation of excited states with circuit depths that are comparable to ground state simulations. The method also allows for easy incorporation of additional constraints to target specific symmetry sectors. The demonstration follow the general approach outlined in the original paper by Higgott et al [11]. The focus of this tutorial is on the algorithm itself  and not on a specific NISQ hardware implementation which may require additional work. Hence, we will confine ourselves to abstraction layers such as the Operator Flow (opflow) [15] layer of IBM Qiskit [16] which offers a convenient language quantum mechanics practitioners can work with. For general background on Qiskit and VQE in the context of quantum chemistry, readers are referred to source materials on Qiskit-Nature [17]."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "febe19f0",
   "metadata": {},
   "source": [
    "## Outline of VQD"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "494bfab0",
   "metadata": {},
   "source": [
    "The Variational Quantum Deflation (VQD) algorithm [11] exploits the mutual orthogonality of the eigenstates of a Hermitian operator, in our case the Hamiltonian, to systematically find excited states using a constrained optimization approach. The necessary orthogonality constraint is introduced in the form of an $\\textit{overlap}$ penalty term in the cost function which is to be variationally optimized using a parameterized circuit ansatz. Concretely, while in VQE for ground states we vary the circuit parameters $\\theta$ to minimize the expectation \n",
    "\n",
    "$E(\\theta) \\equiv \\langle \\psi(\\theta) | H | \\psi(\\theta) \\rangle$ \n",
    "\n",
    "of the Hamiltonian $H$, in VQD, the more general cost function \n",
    "\n",
    "$F(\\theta_k) \\equiv \\langle \\psi(\\theta_k) | H | \\psi(\\theta_k) \\rangle + \\sum_{i=0}^{k-1} \\beta_i |\\langle \\psi(\\theta_k) | \\psi(\\theta_i) \\rangle |^2 $\n",
    "\n",
    "is minimized for each excited state $|\\psi(\\theta_k)\\rangle$ of interest. The second term on the right hand side is the overlap penalty term that enforces approximate orthogonality of the target state $|\\psi(\\theta_k)\\rangle$ with respect to every other previously identified eigenstate $|\\psi(\\theta_i)\\rangle$. For appropriately chosen  multipliers $\\beta_i$, the minimum of the cost function $F(\\theta_k)$ yields the energy of the state $|\\psi(\\theta_i)\\rangle$ as shown by Higgott et al [11]. \n",
    "\n",
    "Given the above, there are a few implementation details we need to consider: \n",
    "#### (i) Overlap estimation \n",
    "Since our variational ansatz states are of the form \n",
    "\n",
    "$|\\psi(\\theta_k) \\rangle \\equiv U(\\theta_k) |0\\rangle$\n",
    "\n",
    "specified by parameterized unitaries $U(\\theta_k)$, for the overlap penalty term, we can directly estimate \n",
    "\n",
    "$|\\langle \\psi(\\theta_i) | \\psi(\\theta_k) \\rangle |^2 = |\\langle 0 | U(\\theta_i)^{\\dagger} U(\\theta_k) |0 \\rangle |^2  = \\langle 0 | U(\\theta_k)^{\\dagger} U(\\theta_i) |0 \\rangle \\langle 0 |U(\\theta_i)^{\\dagger} U(\\theta_k) |0 \\rangle $\n",
    "\n",
    "which amounts to measuring the expectation value of the $n$-qubit projection operator $|0\\rangle\\langle0|$ in the state $U(\\theta_i)^{\\dagger} U(\\theta_k) |0 \\rangle $. We implement this below using Qiskit's opflow. As noted by Higgott et al [11] inverting the circuit describing $U(\\theta_i)$ only leads to an approximation of $U(\\theta_i)^{\\dagger}$ which maybe variationally optimized separately where high precision is needed. \n",
    "#### (ii) Storage of optimal parameters $\\lbrace \\theta_i \\rbrace$\n",
    "Since finding the state $|\\psi(\\theta_k)\\rangle$ requires knowledge of all preceding eigenstates specified by $\\theta_0, \\theta_1, ..., \\theta_{k-1}$, the parameter set $\\lbrace \\theta_i \\rbrace$ needs to be stored for on-the-fly retrieval within an iterative scheme. This is not a problem however since our working assumption is that the parameterization is compact enough to be stored in classical RAM while yielding circuits expressive enough to approximate useful quantum states. In the implementation below we store the optimal parameters simply as numpy arrays and use them not only within an excited state search at a given molecular geometry but also to provide starting guess parameters in a potential energy surface calculation.\n",
    "#### (iii) Choice of circuit ansatz\n",
    "Since the primary goal of this exercise is to reproduce the main result of Figure 2 from the original VQD paper [11], we employ the generic UCCGSD [18] variant of the unitary coupled cluster (UCC) ansatz which is the same circuit ansatz used in [11]. Conveniently, UCCGSD is already implemented in Qiskit. One can of course explore other variations of circuit ansatze on top this basic implementation. Note that we use two Trotter iterations with the UCC ansatz as it is found empirically that a single Totter step may not lead to expressive enough circuits for excited states."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ae4d9ba9",
   "metadata": {},
   "source": [
    "### Implementation for State Vector Simulators"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "82da892e",
   "metadata": {},
   "source": [
    "We start with some necessary imports."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "75089d0a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from qiskit_nature.drivers import UnitsType, Molecule\n",
    "from qiskit_nature.drivers.second_quantization import (\n",
    "    ElectronicStructureDriverType,\n",
    "    ElectronicStructureMoleculeDriver,\n",
    ")\n",
    "from qiskit_nature.problems.second_quantization.electronic import ElectronicStructureProblem\n",
    "from qiskit_nature.converters.second_quantization import QubitConverter\n",
    "from qiskit_nature.mappers.second_quantization import ParityMapper, JordanWignerMapper\n",
    "from qiskit_nature.properties.second_quantization.electronic import ElectronicEnergy, ParticleNumber, AngularMomentum, Magnetization, DipoleMoment\n",
    "from qiskit_nature.transformers.second_quantization.electronic import ActiveSpaceTransformer\n",
    "from qiskit_nature.algorithms.ground_state_solvers import GroundStateEigensolver\n",
    "\n",
    "from qiskit_nature.circuit.library import UCCSD, HartreeFock, initial_states\n",
    "\n",
    "from qiskit.algorithms.optimizers import SPSA\n",
    "from qiskit_nature.operators.second_quantization import FermionicOp\n",
    "from qiskit.opflow import SummedOp, StateFn, PrimitiveOp"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "18c6e654",
   "metadata": {},
   "source": [
    "The **VQD** class as defined below handles the tasks necessary to carry out the iterative VQD excited state search given a qubit Hamiltonian, a circuit wavefunction ansatz and a specified number of excited states. This class therefore requires a set of qubit operators and a circuit wavefunction ansatz to be provided at instantiation time where we set up necessary storage and specify the backend associated with simulating the circuits. \n",
    "\n",
    "The **get_overlap** function calculates the overlap between ansatz states using the n-qubit $|0\\rangle\\langle0|$ projector as outlined above.  \n",
    "\n",
    "The **get_expectation** function simply measures the expectation of a diagonal measurement given a set of parameters specifying an ansatz state. \n",
    "\n",
    "Both functions use the Qiskit opflow syntax.\n",
    "\n",
    "The **cost_fun_gen** function puts together the VQD cost function expression and includes a loop for calculating  overlaps between the target state and all previous eigenstates. \n",
    "\n",
    "The **calculate function** loops over each of the requested target states and calls the classical optimizer (P_BFGS in this case) to refine the parameters for each eigenstate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "e82588d3",
   "metadata": {},
   "outputs": [],
   "source": [
    "from qiskit.opflow import StateFn, ExpectationFactory, CircuitStateFn, ListOp, CircuitSampler\n",
    "from qiskit.opflow import I, X, Y, Z, Zero, One, Plus, Minus, PauliExpectation\n",
    "from qiskit.providers.aer import AerSimulator\n",
    "from qiskit.algorithms.optimizers import P_BFGS, L_BFGS_B, NELDER_MEAD, COBYLA\n",
    "import numpy.random as npr\n",
    "import scipy.linalg as sl\n",
    "from scipy.optimize import minimize\n",
    "\n",
    "class VQD:\n",
    "    \n",
    "    def __init__(self, qOps, wfnA, nEx, states=np.array([])):\n",
    "        self.qOps = qOps\n",
    "        self.wfnA = wfnA\n",
    "        self.nEx = nEx\n",
    "        self.states = states\n",
    "        \n",
    "        hq_op = self.qOps[0]  #Hamiltonian\n",
    "        \n",
    "        #Construct the n-qubit |0><0| projection operator needed for overlap estimation using opflow .\n",
    "        Qp = (1/2) * ( I + Z )\n",
    "        self.zProj = Qp\n",
    "        for iq in range(1, hq_op.num_qubits):\n",
    "            self.zProj ^= Qp\n",
    "\n",
    "        #Recast the wavefunction ansatz to a CircuitStateFn for opflow\n",
    "        self.wf_circ_op = CircuitStateFn(wfnA)\n",
    "                   \n",
    "        self.backend = AerSimulator(device='CPU', blocking_enable=True, method='statevector', batched_shots_gpu=True)\n",
    "        \n",
    "        expectation = ExpectationFactory.build(operator=hq_op,backend=self.backend,include_custom=True)\n",
    "        observable_meas = expectation.convert(StateFn(hq_op, is_measurement=True))\n",
    "        self.expect_op = observable_meas.compose(self.wf_circ_op).reduce()\n",
    "        \n",
    "        exp_proj = ExpectationFactory.build(operator=self.zProj,backend=self.backend,include_custom=True)\n",
    "        self.proj_meas = exp_proj.convert(StateFn(self.zProj, is_measurement=True))\n",
    "        \n",
    "        if not self.states.any():\n",
    "            self.wfn_params = np.eye(len(wfnA.parameters), nEx+1)\n",
    "        else:\n",
    "            self.wfn_params = self.states\n",
    "        self.nFound = 0\n",
    "        self.LagM = 3.0*np.ones(nEx)\n",
    "        self.optimizer = P_BFGS(maxfun=2000, ftol=0.000001, iprint=-1, max_processes=12)\n",
    "        self.fcount = 0\n",
    "        self.curr_state = 0\n",
    "        self.eigenvals = []\n",
    "\n",
    "    def get_overlap(self, wfn_anz, p_dict1, p_dict2):\n",
    "        \"\"\"\n",
    "        Function to calculate state overlap <state2 | state1> using OpFlow\n",
    "        ----Parameters----\n",
    "        wfn_anz: A parameterized circuit StateFn ansatz with unbound parameters\n",
    "        p_dict1: A dictionary of paramers to bind to obtain state1\n",
    "        p_dict2: A dictionary of paramers to bind to obtain state2\n",
    "        \"\"\"\n",
    "        state1 = wfn_anz.bind_parameters(p_dict1)\n",
    "        state2 = wfn_anz.bind_parameters(p_dict2)\n",
    "        state = CircuitStateFn(state1.compose(state2.inverse()))\n",
    "        exp_ovlp = self.proj_meas.compose(state).reduce()\n",
    "        return exp_ovlp.eval()\n",
    "    \n",
    "    def get_expectation(self, Mobj, p_dict):\n",
    "        \"\"\"\n",
    "        Function to calculate expectation values using OpFlow\n",
    "        ----Parameters----\n",
    "        Mobj: An OpFlow diagonal measurement object with unbound parameters\n",
    "        p_dict: A dictionary of paramers to bind\n",
    "        \"\"\"\n",
    "        #Bind all relevant parameters\n",
    "        expects = Mobj.bind_parameters(p_dict)\n",
    "        \n",
    "        #Call the eval function on the bound expectation object to get the results\n",
    "        res = expects.eval()\n",
    "        return res    \n",
    "    \n",
    "    def cost_fun_gen(self, params):\n",
    "        \"\"\"\n",
    "        Function that evalues the cost function for deflation\n",
    "        ----Parameters-----\n",
    "        params: parameters of the wf circuit ansatz as a list\n",
    "        \"\"\"\n",
    "        # Create a params dict from the provided list\n",
    "        p_vec = list(self.wf_circ_op.parameters)[0].vector\n",
    "        p_dict = {p_vec: params}\n",
    "\n",
    "        # Evaluate the Hamiltonian expectation value for the current parameter set using the saved diag measrement obj\n",
    "        ev = self.get_expectation(self.expect_op, p_dict)\n",
    "        pen = 0\n",
    "        for i in range(self.nFound):\n",
    "            params_i = (self.wfn_params[:,i])\n",
    "            p_dict_i = {p_vec: params_i}\n",
    "            ovlp = self.get_overlap(self.wfnA, p_dict, p_dict_i)\n",
    "            pen += self.LagM[0] * np.abs(ovlp)\n",
    "            \n",
    "        cost = np.real(ev) +  pen\n",
    "        \n",
    "        self.fcount += 1\n",
    "        #Uncomment for detailed optimization logging\n",
    "        #if self.fcount%50 == 0:\n",
    "        #    print(f'cost, ev, pen is: {cost, ev, pen}')\n",
    "        return cost\n",
    "    \n",
    "    def calculate(self):\n",
    "        #start with the 0th exciated state i.e. ground state\n",
    "        for iex in range(self.nEx+1):\n",
    "            self.curr_state = iex\n",
    "            if self.states.any():\n",
    "                p0 = self.states[:,iex]\n",
    "            else:\n",
    "                if iex == 0:\n",
    "                    p0 = self.wfnA.preferred_init_points\n",
    "                else:\n",
    "                    p0 = (np.pi/2) * np.random.rand(len(self.wfnA.preferred_init_points))\n",
    "                \n",
    "            bounds = [(-2 * np.pi, 2 * np.pi)] * len(self.wfnA.parameters)\n",
    "            res = self.optimizer.minimize(fun=self.cost_fun_gen, x0=p0, jac=None, bounds=bounds)\n",
    "            eigenval = res.fun\n",
    "            eig_params = res.x\n",
    "            self.nFound += 1\n",
    "            if self.nEx >= iex:\n",
    "                self.wfn_params[:,iex] = eig_params\n",
    "            print(f'index, eigenValue, eigenVector:{iex, eigenval, eig_params}')\n",
    "            self.eigenvals.append(eigenval)\n",
    "        return (self.eigenvals, self.wfn_params)\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "71aaacee",
   "metadata": {},
   "source": [
    "The **ExcitedStateCalculator** class defined below handles the tasks associated with setting up the qubit operators and circuit state ansatz for a specified molecular geometry at instantiation time. \n",
    "\n",
    "It provides a **quantum_solve** function which makes use of the VQD class defined above to perform a VQD excited state search for with the chosen qubit operators and circuit state ansatz.\n",
    "\n",
    "A convenience function **classical_solve** is also provided which diagonalizes a matrix representation of the specified qubit Hamiltonian using SciPy to yield exact results we can compare against VQD."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "d743cb7f",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ExcitedStateCalculator:\n",
    "    def __init__(self, geometry):\n",
    "        self.geometry = geometry\n",
    "        # define molecule\n",
    "        self.mol = Molecule(geometry=geometry, charge=0, multiplicity=1)\n",
    "\n",
    "        # specify PYSCF classical driver\n",
    "        self.driver = ElectronicStructureMoleculeDriver(self.mol, basis=\"sto3g\", driver_type=ElectronicStructureDriverType.PYSCF)\n",
    "\n",
    "        # run the classical SCF driver\n",
    "        self.mf_result = self.driver.run()  \n",
    "        \n",
    "        # get particle number\n",
    "        self.mf_energy = self.mf_result.get_property(ElectronicEnergy)\n",
    "        self.particle_number = self.mf_result.get_property(ParticleNumber)\n",
    "        self.num_electrons = self.particle_number.num_particles\n",
    "        self.num_spin_orbitals = self.particle_number.num_spin_orbitals\n",
    "        self.num_molecular_orbitals = int(self.num_spin_orbitals//2)\n",
    "        \n",
    "        #specify active space transformation (not needed for this example)\n",
    "        active_space_trafo = ActiveSpaceTransformer(num_electrons=self.num_electrons, \n",
    "                                                    num_molecular_orbitals=self.num_molecular_orbitals)\n",
    "\n",
    "        # define electronic structure problem\n",
    "        self.es_problem = ElectronicStructureProblem(self.driver, transformers=[active_space_trafo])   \n",
    "        \n",
    "        #specify a quibit mapping (Jordan Wigner) of second quantized operators\n",
    "        qubit_converter = QubitConverter(JordanWignerMapper(), two_qubit_reduction=False)\n",
    "        \n",
    "        #specify a HartreeFock initial state \n",
    "        hf_init = HartreeFock(self.num_spin_orbitals, self.num_electrons, qubit_converter)\n",
    "        \n",
    "        #instantiate a generalized UCCGSD ansatz circuit with 2 Trotter steps.\n",
    "        self.wf_ansatz = UCCSD(qubit_converter=qubit_converter, num_particles=self.num_electrons, \n",
    "                               num_spin_orbitals=self.num_spin_orbitals, reps=2, initial_state=hf_init, \n",
    "                               preserve_spin=False, generalized=False)\n",
    "\n",
    "        #perform the Fermion to qubit mapping of second quantized operators \n",
    "        self.q_ops = qubit_converter.map(self.es_problem.second_q_ops())\n",
    "        \n",
    "        \n",
    "    def quantum_solve(self, num_excited_states, guess_state_parameters=np.array([])):\n",
    "        print(self.wf_ansatz)\n",
    "        vqdi = VQD(self.q_ops, self.wf_ansatz, num_excited_states, states=guess_state_parameters )\n",
    "        (eigenvalues, result_states) = vqdi.calculate()\n",
    "        #add nuclear repulsion to electronic energy\n",
    "        eigenvalues = [ x + self.mf_energy.nuclear_repulsion_energy for x in eigenvalues ]\n",
    "        return (eigenvalues, result_states)\n",
    "    \n",
    "    def classical_solve(self, num_excited_states):\n",
    "        #Extract relevant qubit operators\n",
    "        hq_op = self.q_ops[0]  #Hamiltonian\n",
    "        nq_op = self.q_ops[1]  #Number operator\n",
    "        \n",
    "        #extract matrix representations of qubit operators\n",
    "        H_Mat = hq_op.to_matrix()\n",
    "        N_Mat = nq_op.to_matrix()\n",
    "        \n",
    "        #diagonalize to extrant eigen energies and eigenfunctions\n",
    "        omega, psi = sl.eigh(H_Mat)\n",
    "        \n",
    "        #evaluate matrix elements of operators in eigenbasis\n",
    "        N_expect = np.dot(psi.conj().T,np.dot(N_Mat, psi))\n",
    "        E_expect = np.dot(psi.conj().T,np.dot(H_Mat, psi))\n",
    "        \n",
    "        #collect energies corresponding to states with the correct number of electrons\n",
    "        c_eigs = []\n",
    "        for i in range(N_Mat.shape[0]):\n",
    "            if abs(N_expect[i,i] - np.sum(self.num_electrons)) < 1e-8:\n",
    "                c_eigs.append(E_expect[i,i] + self.mf_energy.nuclear_repulsion_energy)\n",
    "        c_eigs = np.real(np.array(c_eigs))\n",
    "        return np.sort(c_eigs)[0:num_excited_states+1]\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20475e55",
   "metadata": {},
   "source": [
    "Having defined the VQD and ExcitedStateCalculator classes above we are now ready to execute a simple loop over molecular geometries to generate ground and excited state potential energy surfaces (PES) for reproducing Figure 2 of the VQD paper [11]. \n",
    "\n",
    "Accordingly, we choose the **H$_2$** molecule in the **sto-3g** minimal basis set to set up a **4 qubit VQD** problem and loop over bond distances to generate the PES. There are a total of ${4 \\choose 2} = 6$ eigenstates with particle number 2 or 5 $\\textit{excited}$ states to calculate. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "966f59f8",
   "metadata": {},
   "source": [
    "After the VQD is done we call the **classical_solve** function to get the exact results for comparison at the same geometries. This of course can also be done in the same loop above used for VQD."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "5fd1bea3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(0.3, array([-0.60180371,  0.83607559,  0.83607559,  0.83607559,  1.15771263,\n",
      "        2.64874383])), (0.4, array([-0.9141497 ,  0.2829341 ,  0.2829341 ,  0.2829341 ,  0.61196495,\n",
      "        1.86070463])), (0.5, array([-1.05515979, -0.07074011, -0.07074011, -0.07074011,  0.26700034,\n",
      "        1.30148575])), (0.6000000000000001, array([-1.11628601, -0.31096009, -0.31096009, -0.31096009,  0.0365012 ,\n",
      "        0.89008467])), (0.7, array([-1.13618945, -0.47845306, -0.47845306, -0.47845306, -0.1204519 ,\n",
      "        0.5833141 ])), (0.8, array([-1.13414767, -0.5971778 , -0.5971778 , -0.5971778 , -0.22792423,\n",
      "        0.35228457])), (0.9000000000000001, array([-1.12056028, -0.68284939, -0.68284939, -0.68284939, -0.301706  ,\n",
      "        0.17588132])), (1.0, array([-1.10115033, -0.74587179, -0.74587179, -0.74587179, -0.35229063,\n",
      "        0.03904763])), (1.1, array([-1.07919294, -0.7929597 , -0.7929597 , -0.7929597 , -0.38651524,\n",
      "       -0.0683013 ])), (1.2, array([-1.05674075, -0.82844335, -0.82844335, -0.82844335, -0.40886041,\n",
      "       -0.15271436])), (1.3, array([-1.03518627, -0.85523694, -0.85523694, -0.85523694, -0.42240202,\n",
      "       -0.21860355])), (1.4000000000000001, array([-1.01546825, -0.87542794, -0.87542794, -0.87542794, -0.42938376,\n",
      "       -0.26922131])), (1.5, array([-0.99814935, -0.89058478, -0.89058478, -0.89058478, -0.43151291,\n",
      "       -0.3071925 ])), (1.7, array([-0.97142669, -0.91033743, -0.91033743, -0.91033743, -0.42619176,\n",
      "       -0.35387022])), (1.9, array([-0.95433885, -0.92116973, -0.92116973, -0.92116973, -0.41374888,\n",
      "       -0.37334368])), (2.1, array([-0.94437468, -0.92699269, -0.92699269, -0.92699269, -0.39840556,\n",
      "       -0.37654036])), (2.3, array([-0.93892239, -0.93005864, -0.93005864, -0.93005864, -0.38249453,\n",
      "       -0.37096823])), (2.5, array([-0.93605492, -0.93163909, -0.93163909, -0.93163909, -0.36721899,\n",
      "       -0.36129348]))]\n"
     ]
    }
   ],
   "source": [
    "n_excited_states = 5\n",
    "counter = 0\n",
    "geom_vs_efci = []\n",
    "    \n",
    "for bond_distance in [ 0.3 + i*0.1 for i in range(12) ] + [ 1.5 + i*0.2 for i in range(6) ]:\n",
    "    #define molecular geometry \n",
    "    geometry = [[\"H\", [0.0, 0.0, 0.0]], [\"H\", [0.0, 0.0, bond_distance]]]\n",
    "    \n",
    "    #instantiate the solver\n",
    "    \n",
    "    pes = ExcitedStateCalculator(geometry)\n",
    "    fci_eigs = pes.classical_solve(n_excited_states)\n",
    "\n",
    "    geom_vs_efci.append((bond_distance, fci_eigs))\n",
    "    \n",
    "    counter += 1\n",
    "\n",
    "print(geom_vs_efci)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "205f093f",
   "metadata": {},
   "source": [
    "Finally, we are ready to plot up the results. As noted in reference [11] without additional symmetry constraints the VQD algorithm using the UCC ansatz finds all six eigenstates states of the sto-3g H$_2$ molecule with 2 electrons. We see only 4 curves below because of a triplet spin state which is 3-fold degenerate."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "8913d395",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "n_excited_states = 5\n",
    "x = [ t[0] for t in geom_vs_energies ]\n",
    "for iex in range(n_excited_states + 1):\n",
    "    e_ex = [ t[1][iex] for t in geom_vs_energies ]\n",
    "    fci_ex = [ t[1][iex] for t in geom_vs_efci ]\n",
    "    if iex == 0:\n",
    "        plt.plot(x, fci_ex, color='red', label='Exact')\n",
    "        plt.plot(x, e_ex, '.', color='blue', label='VQD')\n",
    "    else:\n",
    "        plt.plot(x, fci_ex, color='red')\n",
    "        plt.plot(x, e_ex, '.', color='blue')\n",
    "        \n",
    "\n",
    "plt.ylabel('Energy (a.u)')\n",
    "plt.xlabel('Bond distance ($\\AA$)')\n",
    "\n",
    "plt.xlim([0.25, 2.5])\n",
    "plt.ylim([-1.25, 1.05])    \n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f632186",
   "metadata": {},
   "source": [
    "As expected, the potential energy surfaces show good agreement between the exact SciPy results and the VQD algorithm since after all we ran the latter on a noiseless state vector simulator as backend and the UCC ansatz is sufficiently expressive for H$_2$. \n",
    "\n",
    "We can plot the difference between the VQD and exact energies as shown below and find that for all except the highest energy state, the difference is in the sub micro-Hartree range."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "436cacbe",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = [ t[0] for t in geom_vs_energies ]\n",
    "for iex in range(n_excited_states + 1):\n",
    "    e_ex = [ t[1][iex] for t in geom_vs_energies ]\n",
    "    fci_ex = [ t[1][iex] for t in geom_vs_efci ]\n",
    "    d_ene = [ abs(e_ex[i] - fci_ex[i]) for i in range(len(geom_vs_efci))  ]\n",
    "    lbl = 'error state'+str(iex)\n",
    "    plt.plot(x, d_ene, marker='.',label=lbl)\n",
    "plt.ylabel('Energy error (a.u)')\n",
    "plt.xlabel('Bond distance ($\\AA$)')\n",
    "plt.xlim([0.25, 2.5])\n",
    "plt.yscale('log')\n",
    "plt.legend()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ab57564",
   "metadata": {},
   "source": [
    "## Additional Constraints"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29b19655",
   "metadata": {},
   "source": [
    "In many applications not all of the possible eigenstates are relevant and only a subset of useful states need to be calculated. Such states can often be selected by specifying symmetry constraints. Ideally, it would be possible to incorporate the constraints into the wavefuction ansatz iself which would lead to maximal resource savings but where that is impractical an explicit constrained optimization can be used instead. A nice feature of VQD is that it straightforwardly permits the incorporation of additional constraints during the optimization process to target only specific excited states. "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a625423",
   "metadata": {},
   "source": [
    "#### Spin-constrained VQD"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac3e2349",
   "metadata": {},
   "source": [
    "In the code below we implement a total spin constraint to return states only in the spin singlet $(S = 0)$ sector of the 2 electron system and skip over the 3-fold degenerate triplet states of sto-3g H$_2$. To do so the VQD class defined above is simply extended to a **SpinConstrainedVQD** class which defines an expectation measurement for the $S^2$ operator when instantiated and the cost function **cost_fun_gen** is extended to include an additional penalty term that ensures the expectation of $S^2$ is 0. Note that since $S^2 \\ge 0$ and we are targeting its lowest possible value we do not need to use a quadratic form to specify the constraint which would be the case in general [19]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "92f9da12",
   "metadata": {},
   "outputs": [],
   "source": [
    "class SpinConstrainedVQD(VQD):\n",
    "    \n",
    "    def __init__(self, qOps, wfnA, nEx, states=np.array([])):\n",
    "        super().__init__(qOps, wfnA, nEx, states)\n",
    "        \n",
    "        # To implement explicit total Spin constraint use the S^2 operator \n",
    "        #from the set of available qubit operators.\n",
    "        S2_op = self.qOps[2]\n",
    "        exp_S2 = ExpectationFactory.build(operator=S2_op,backend=self.backend,include_custom=True)\n",
    "        S2_meas = exp_S2.convert(StateFn(S2_op, is_measurement=True))\n",
    "        self.expect_S2 = S2_meas.compose(self.wf_circ_op).reduce()\n",
    "            \n",
    "    def cost_fun_gen(self, params):\n",
    "        \"\"\"\n",
    "        Function that evalues the cost function for deflation\n",
    "        ----Parameters-----\n",
    "        params: parameters of the wf circuit ansatz as a list\n",
    "        \"\"\"\n",
    "        # Create a params dict from the provided list\n",
    "        p_vec = list(self.wf_circ_op.parameters)[0].vector\n",
    "        p_dict = {p_vec: params}\n",
    "\n",
    "        # Evaluate the Hamiltonian expectation value for the current parameter set using the saved diag measrement obj\n",
    "        ev = self.get_expectation(self.expect_op, p_dict)\n",
    "        \n",
    "        # Evaluate the S^2 expectation value for total spin constraint\n",
    "        S2_ev = self.get_expectation(self.expect_S2, p_dict)\n",
    "\n",
    "        pen = 0\n",
    "        for i in range(self.nFound):\n",
    "            params_i = (self.wfn_params[:,i])\n",
    "            p_dict_i = {p_vec: params_i}\n",
    "            ovlp = self.get_overlap(self.wfnA, p_dict, p_dict_i)\n",
    "            pen += self.LagM[0] * np.abs(ovlp)\n",
    "            \n",
    "        cost = np.real(ev) +  pen + 3 * np.real(S2_ev) #cost now includes additional penalty to force total spin towards 0.\n",
    "        \n",
    "        self.fcount += 1\n",
    "        #Uncomment for detailed optimization logging        \n",
    "        #if self.fcount%50 == 0:\n",
    "        #    print(f'cost, ev, pen, S2_ev is: {cost, ev, pen, S2_ev}')\n",
    "        return cost        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cba8f846",
   "metadata": {},
   "source": [
    "We also define a **ConstrainedExcitedStateCalculator** which extends the **ExcitedStateCalculator** class above and over-rides the **quantum_solve** and **classical_solve** methods to handle the additional spin constraint. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6068b8cb",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ConstrainedExcitedStateCalculator(ExcitedStateCalculator):\n",
    "    def __init__(self, geometry):\n",
    "        super().__init__(geometry)        \n",
    "        \n",
    "    def quantum_solve(self, num_excited_states, guess_state_parameters=None):\n",
    "        print(self.wf_ansatz)\n",
    "        vqdi = SpinConstrainedVQD(self.q_ops, self.wf_ansatz, num_excited_states, states=guess_state_parameters )\n",
    "        (eigenvalues, result_states) = vqdi.calculate()\n",
    "        #add nuclear repulsion to electronic energy\n",
    "        eigenvalues = [ x + self.mf_energy.nuclear_repulsion_energy for x in eigenvalues ]\n",
    "        return (eigenvalues, result_states)\n",
    "    \n",
    "    def classical_solve(self, num_excited_states):\n",
    "        #Extract relevant qubit operators\n",
    "        hq_op = self.q_ops[0]  #Hamiltonian\n",
    "        nq_op = self.q_ops[1]  #Number operator\n",
    "        s2_op = self.q_ops[2]  #S^2 operator\n",
    "        \n",
    "        #extract matrix representations of qubit operators\n",
    "        H_Mat = hq_op.to_matrix()\n",
    "        N_Mat = nq_op.to_matrix()\n",
    "        S2_Mat = s2_op.to_matrix()\n",
    "        \n",
    "        #diagonalize to extrant eigen energies and eigenfunctions\n",
    "        omega, psi = sl.eigh(H_Mat)\n",
    "        \n",
    "        #evaluate matrix elements of operators in eigenbasis\n",
    "        N_expect = np.dot(psi.conj().T,np.dot(N_Mat, psi))\n",
    "        E_expect = np.dot(psi.conj().T,np.dot(H_Mat, psi))\n",
    "        S2_expect = np.dot(psi.conj().T,np.dot(S2_Mat, psi))\n",
    "        \n",
    "        #collect energies corresponding to states with the correct number of electrons and total Spin\n",
    "        c_eigs = []\n",
    "        for i in range(N_Mat.shape[0]):\n",
    "            if abs(N_expect[i,i] - np.sum(self.num_electrons)) < 1e-8 and abs(S2_expect[i,i]) < 1e-2:\n",
    "                c_eigs.append(E_expect[i,i] + self.mf_energy.nuclear_repulsion_energy)\n",
    "        c_eigs = np.real(np.array(c_eigs))\n",
    "        return np.sort(c_eigs)[0:num_excited_states+1]\n",
    "        "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e83952dc",
   "metadata": {},
   "source": [
    "We can now run the spin-constrained version of the calculation. For this we set the total number of excited states to 2 which is what we are left with if we remove the 3-fold degenerate triplet in sto-3g H$_2$. In real applications the total number of available excited states far exceeds the number we are typically interested in and we do not need to worry about asking for too many states. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "e77a494e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[(0.3, array([-0.60180371,  1.15771263,  2.64874383])), (0.4, array([-0.9141497 ,  0.61196495,  1.86070463])), (0.5, array([-1.05515979,  0.26700034,  1.30148575])), (0.6000000000000001, array([-1.11628601,  0.0365012 ,  0.89008467])), (0.7, array([-1.13618945, -0.1204519 ,  0.5833141 ])), (0.8, array([-1.13414767, -0.22792423,  0.35228457])), (0.9000000000000001, array([-1.12056028, -0.301706  ,  0.17588132])), (1.0, array([-1.10115033, -0.35229063,  0.03904763])), (1.1, array([-1.07919294, -0.38651524, -0.0683013 ])), (1.2, array([-1.05674075, -0.40886041, -0.15271436])), (1.3, array([-1.03518627, -0.42240202, -0.21860355])), (1.4000000000000001, array([-1.01546825, -0.42938376, -0.26922131])), (1.5, array([-0.99814935, -0.43151291, -0.3071925 ])), (1.7, array([-0.97142669, -0.42619176, -0.35387022])), (1.9, array([-0.95433885, -0.41374888, -0.37334368])), (2.1, array([-0.94437468, -0.39840556, -0.37654036])), (2.3, array([-0.93892239, -0.38249453, -0.37096823])), (2.5, array([-0.93605492, -0.36721899, -0.36129348]))]\n"
     ]
    }
   ],
   "source": [
    "n_excited_states = 2\n",
    "counter = 0\n",
    "geom_vs_efci = []\n",
    "    \n",
    "for bond_distance in [ 0.3 + i*0.1 for i in range(12) ] + [ 1.5 + i*0.2 for i in range(6) ]:\n",
    "    #define molecular geometry \n",
    "    geometry = [[\"H\", [0.0, 0.0, 0.0]], [\"H\", [0.0, 0.0, bond_distance]]]\n",
    "    \n",
    "    #instantiate the solver\n",
    "    \n",
    "    pes = ConstrainedExcitedStateCalculator(geometry)\n",
    "    fci_eigs = pes.classical_solve(n_excited_states)\n",
    "\n",
    "    geom_vs_efci.append((bond_distance, fci_eigs))\n",
    "    \n",
    "    counter += 1\n",
    "\n",
    "print(geom_vs_efci)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a389bf3",
   "metadata": {},
   "source": [
    "Plotting the calculated energies we see that we have skipped over the triplet excited states as intended and see only  the three spin siglet states."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "ca077ad4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "x = [ t[0] for t in geom_vs_energies ]\n",
    "for iex in range(n_excited_states + 1):\n",
    "    e_ex = [ t[1][iex] for t in geom_vs_energies ]\n",
    "    fci_ex = [ t[1][iex] for t in geom_vs_efci ]\n",
    "    if iex == 0:\n",
    "        plt.plot(x, fci_ex, color='red', label='Exact')\n",
    "        plt.plot(x, e_ex, '.', color='blue', label='VQD')\n",
    "    else:\n",
    "        plt.plot(x, fci_ex, color='red')\n",
    "        plt.plot(x, e_ex, '.', color='blue')\n",
    "\n",
    "plt.ylabel('Energy (a.u)')\n",
    "plt.xlabel('Bond distance ($\\AA$)')\n",
    "\n",
    "plt.xlim([0.25, 2.5])\n",
    "plt.ylim([-1.25, 1.05])  \n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c23acb31",
   "metadata": {},
   "source": [
    "Plot the energy differences between the exact and spin-constrained VQD solutions, we see that the additional constraint slightly increases the error as the optimization problem gets harder for the classical optimizer but agreement is still in the sub micro-Hartree range."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "96452203",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = [ t[0] for t in geom_vs_energies ]\n",
    "for iex in range(n_excited_states + 1):\n",
    "    e_ex = [ t[1][iex] for t in geom_vs_energies ]\n",
    "    fci_ex = [ t[1][iex] for t in geom_vs_efci ]\n",
    "    d_ene = [ abs(e_ex[i] - fci_ex[i]) for i in range(len(geom_vs_efci))  ]\n",
    "    lbl = 'error state'+str(iex)\n",
    "    plt.plot(x, d_ene, marker='.',label=lbl)\n",
    "\n",
    "plt.ylabel('Energy error (a.u)')\n",
    "plt.xlabel('Bond distance ($\\AA$)')\n",
    "\n",
    "plt.xlim([0.25, 2.5])\n",
    "plt.yscale('log')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "1cf47ec9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<h3>Version Information</h3><table><tr><th>Qiskit Software</th><th>Version</th></tr><tr><td><code>qiskit-terra</code></td><td>0.20.1</td></tr><tr><td><code>qiskit-aer</code></td><td>0.10.4</td></tr><tr><td><code>qiskit-ignis</code></td><td>0.7.0</td></tr><tr><td><code>qiskit-ibmq-provider</code></td><td>0.19.1</td></tr><tr><td><code>qiskit</code></td><td>0.36.1</td></tr><tr><td><code>qiskit-nature</code></td><td>0.3.2</td></tr><tr><td><code>qiskit-machine-learning</code></td><td>0.4.0</td></tr><tr><th>System information</th></tr><tr><td>Python version</td><td>3.9.7</td></tr><tr><td>Python compiler</td><td>Clang 10.0.0 </td></tr><tr><td>Python build</td><td>default, Sep 16 2021 08:50:36</td></tr><tr><td>OS</td><td>Darwin</td></tr><tr><td>CPUs</td><td>8</td></tr><tr><td>Memory (Gb)</td><td>16.0</td></tr><tr><td colspan='2'>Mon May 23 12:41:37 2022 PDT</td></tr></table>"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import qiskit.tools.jupyter\n",
    "\n",
    "%qiskit_version_table"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbcaa6b8",
   "metadata": {},
   "source": [
    "That concludes this VQD mini-tutorial. The code provided above should be easily adaptable for exploring other symmetry constraints as well as other molecular systems. Feedback on possible bugs/suggestions for improvement are most welcome!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a785fa5",
   "metadata": {},
   "source": [
    "### Cited References"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2c1453c5",
   "metadata": {},
   "source": [
    "1. \tChen, H., Nusspickel, M., Tilly, J., Booth, G.H.: A variational quantum eigensolver for dynamic correlation functions. Phys. Rev. A. 104, 032405 (2021). https://doi.org/10.1103/PhysRevA.104.032405\n",
    "2. \tZhang, F., Gomes, N., Yao, Y., Orth, P.P., Iadecola, T.: Adaptive variational quantum eigensolvers for highly excited states. Phys. Rev. B. 104, 075159 (2021). https://doi.org/10.1103/PhysRevB.104.075159\n",
    "3. \tTilly, J., Jones, G., Chen, H., Wossnig, L., Grant, E.: Computation of molecular excited states on IBM quantum computers using a discriminative variational quantum eigensolver. Phys. Rev. A. 102, 062425 (2020). https://doi.org/10.1103/PhysRevA.102.062425\n",
    "4. \tYordanov, Y.S., Barnes, C.H.W., Arvidsson-Shukur, D.R.M.: Molecular excited state calculations with the QEB-ADAPT-VQE. ArXiv210606296 Quant-Ph. (2021)\n",
    "5. \tRizzo, J., Libbi, F., Tacchino, F., Ollitrault, P.J., Marzari, N., Tavernelli, I.: One-particle Green’s functions from the quantum equation of motion algorithm. ArXiv220101826 Quant-Ph. (2022)\n",
    "6. \tOllitrault, P.J., Kandala, A., Chen, C.-F., Barkoutsos, P.K., Mezzacapo, A., Pistoia, M., Sheldon, S., Woerner, S., Gambetta, J., Tavernelli, I.: Quantum equation of motion for computing molecular excitation energies on a noisy quantum processor. Phys. Rev. Res. 2, 043140 (2020). https://doi.org/10.1103/PhysRevResearch.2.043140\n",
    "7. \tBierman, J., Li, Y., Lu, J.: Quantum Orbital Minimization Method for Excited States Calculation on Quantum Computer. ArXiv220107963 Phys. Physicsquant-Ph. (2022)\n",
    "8. \tNakanishi, K.M., Mitarai, K., Fujii, K.: Subspace-search variational quantum eigensolver for excited states. Phys. Rev. Res. 1, 033062 (2019). https://doi.org/10.1103/PhysRevResearch.1.033062\n",
    "9. \tBauman, N.P., Liu, H., Bylaska, E.J., Krishnamoorthy, S., Low, G.H., Granade, C.E., Wiebe, N., Baker, N.A., Peng, B., Roetteler, M., Troyer, M., Kowalski, K.: Towards quantum computing for high-energy excited states in molecular systems: quantum phase estimations of core-level states. ArXiv200706185 Phys. Physicsquant-Ph. (2020)\n",
    "10. \tLaRose, R., Tikku, A., O’Neel-Judy, É., Cincio, L., Coles, P.J.: Variational Quantum State Diagonalization. Npj Quantum Inf. 5, 57 (2019). https://doi.org/10.1038/s41534-019-0167-6\n",
    "11. \tHiggott, O., Wang, D., Brierley, S.: Variational Quantum Computation of Excited States. Quantum. 3, 156 (2019). https://doi.org/10.22331/q-2019-07-01-156\n",
    "12. \tPeruzzo, A., McClean, J., Shadbolt, P., Yung, M.-H., Zhou, X.-Q., Love, P.J., Aspuru-Guzik, A., O’Brien, J.L.: A variational eigenvalue solver on a photonic quantum processor. Nat. Commun. 5, 4213 (2014). https://doi.org/10.1038/ncomms5213\n",
    "13. \tTilly, J., Chen, H., Cao, S., Picozzi, D., Setia, K., Li, Y., Grant, E., Wossnig, L., Rungger, I., Booth, G.H., Tennyson, J.: The Variational Quantum Eigensolver: a review of methods and best practices. ArXiv211105176 Quant-Ph. (2021)\n",
    "14. \tExcited states solvers — Qiskit Nature 0.3.1 documentation, https://qiskit.org/documentation/nature/tutorials/04_excited_states_solvers.html\n",
    "15. \tOperator Flow — Qiskit 0.34.2 documentation, https://qiskit.org/documentation/tutorials/operators/01_operator_flow.html\n",
    "16. \tQiskit, https://qiskit.org/\n",
    "17. \tQiskit Nature Documentation — Qiskit Nature 0.3.1 documentation, https://qiskit.org/documentation/nature/\n",
    "18. \tLee, J., Huggins, W.J., Head-Gordon, M., Whaley, K.B.: Generalized Unitary Coupled Cluster Wave functions for Quantum Computation. J. Chem. Theory Comput. 15, 311–324 (2019). https://doi.org/10.1021/acs.jctc.8b01004\n",
    "19. \tKuroiwa, K., Nakagawa, Y.O.: Penalty methods for a variational quantum eigensolver. Phys. Rev. Res. 3, 013197 (2021). https://doi.org/10.1103/PhysRevResearch.3.013197"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
